// /////////////////////////////////////////////////////////////////////////////
//
// Name:            ParticleSysComponent.h
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Declaration of the ParticleSysComponent class.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

#ifndef __PARTICLESYSCOMPONENT_H__
#define __PARTICLESYSCOMPONENT_H__

// Include files
#include "../../dependencies.h"
#include "SceneComponent.h"


// ParticleSysComponent class
//! Component wrapper of Irrlicht's IParticleSystemSceneNode.
//!
//! <b>XML:</b>
//! \code
//! <ParticleSysComponent>
//!    <!-- Properties -->
//! </ParticleSysComponent>
//! \endcode
class ParticleSysComponent : public SceneComponent
{
public:

    // Initialisation and deinitialisation
    //! Constructor (default)
    //! @param parent        The parent entity to which the component should be added.
    //! @param scale         Initial scale of the component.
    ParticleSysComponent(Entity *parent, const vector3df &scale = vector3df(1.0f, 1.0f, 1.0f));
    //! Deconstructor
    ~ParticleSysComponent();

    // Methods
    //! Returns a direct pointer to the IParticleSystemSceneNode.
    //! @note Not available in AngelScript.
    IParticleSystemSceneNode* getParticleSystemSceneNode();

    //! Adds a new particle effector to the particle system.
    //! @param affector      New affector.
    //! @note Not available in AngelScript.
    void addAffector(IParticleAffector *affector);

    //! Adds a point attraction affector.
    //!
    //! <b>XML:</b>
    //! \code
    //! <AttractionAffector>
    //!    <point x="" y="" z="" />
    //!    <speed value="" />
    //!    <attract value="" />
    //!    <affectX value="" />
    //!    <affectY value="" />
    //!    <affectZ value="" />
    //! </AttractionAffector>
    //! \endcode
    //!
    //! @param point         Point to attract particles to.
    //! @param speed         Speed in units per second, to attract to the specified point.
    //! @param attract       Whether the particles attract or detract from this point.
    //! @param affectX       Whether or not this will affect the X position of the particle.
    //! @param affectY       Whether or not this will affect the Y position of the particle.
    //! @param affectZ       Whether or not this will affect the Z position of the particle.
    void addAttractionAffector(const vector3df &point, f32 speed = 1.0f, bool attract = true,
                               bool affectX = true, bool affectY = true, bool affectZ = true);

    //! Adds a fade out particle affector.
    //!
    //! <b>XML:</b>
    //! \code
    //! <FadeOutParticleAffector>
    //!    <targetColor a="" r="" g="" b="" />
    //!    <timeNeededToFadeOut value="" />
    //! </FadeOutParticleAffector>
    //! \endcode
    //!
    //! @param targetColor   Color where to the color of the particle is changed.
    //! @param timeNeededToFadeOut How much time in milli seconds should the affector need to
    //!                            change the color to the targetColor.
    void addFadeOutParticleAffector(const SColor &targetColor = SColor(0, 0, 0, 0),
                                    u32 timeNeededToFadeOut = 1000);

    //! Adds a gravity affector.
    //!
    //! <b>XML:</b>
    //! \code
    //! <GravityAffector>
    //!    <gravity x="" y="" z="" />
    //!    <timeForceLost value="" />
    //! </GravityAffector>
    //!
    //! \endcode
    //! @param gravity       Direction and force of gravity.
    //! @param timeForceLost Time in milliseconds when the force of the emitter is totally
    //!                      lost and the particle does not move any more
    void addGravityAffector(const vector3df &gravity = vector3df(0.0f,-0.03f, 0.0f),
                            u32 timeForceLost = 1000);

    //! Adds a rotation affector.
    //!
    //! <b>XML:</b>
    //! \code
    //! <RotationAffector>
    //!    <speed x="" y="" z="" />
    //!    <pivotPoint x="" y="" z="" />
    //! </RotationAffector>
    //! \endcode
    //!
    //! @param speed         Rotation in degrees per second.
    //! @param pivotPoint    Point to rotate the particles around.
    void addRotationAffector(const vector3df &speed = vector3df(5.0f, 5.0f, 5.0f),
                             const vector3df &pivotPoint = vector3df(0.0f, 0.0f, 0.0f));

    //! Adds a scale particle affector.
    //!
    //! <b>XML:</b>
    //! \code
    //! <ScaleParticleAffector>
    //!    <scaleTo width="" height="" />
    //! </ScaleParticleAffector>
    //! \endcode
    //!
    //! @param scaleTo        Multiple of the size which the particle will be scaled to until
    //!                       deletion.
    void addScaleParticleAffector(const dimension2df &scaleTo = dimension2df(1.0f, 1.0f));

    //! Removes all affectors.
    void removeAffectors();

    //! Gets the particle emitter, which creates the particles.
    //! @note Not available in AngelScript.
    IParticleEmitter* getEmitter();

    //! Sets a particle emitter for the loaded animated mesh component.
    //! @param node                    Pointer to the loaded scene node.
    //! @param useNormalDirection      If true, the direction of each particle created will be the
    //!                                normal of the vertex that it's emitting from. The normal is
    //!                                divided by the normalDirectionModifier parameter,
    //!                                which defaults to 100.0f.
    //! @param direction               Direction and speed of particle emission.
    //! @param normalDirectionModifier If the emitter is using the normal direction then the normal
    //!                                of the vertex that is being emitted from is divided by this
    //!                                number.
    //! @param everyMeshVertex         If true, the emitter will emit between min/max particles
    //!                                every second, for every vertex in the mesh, if false, it
    //!                                will emit between min/max particles from random vertices
    //!                                in the mesh.
    //! @param minParticlesPerSecond   Minimal amount of particles emitted per second.
    //! @param maxParticlesPerSecond   Maximal amount of particles emitted per second.
    //! @param minStartColor           Minimal initial start color of a particle.
    //! @param maxStartColor           Maximal initial start color of a particle.
    //! @param lifeTimeMin             Minimal lifetime of a particle, in milliseconds.
    //! @param lifeTimeMax             Maximal lifetime of a particle, in milliseconds.
    //! @param maxAngleDegrees         Maximal angle in degrees, the emitting direction of the
    //!                                particle will differ from the original direction.
    //! @param minStartSize            Minimal initial start size of a particle.
    //! @param maxStartSize            Maximal initial start size of a particle.
    //! @note Not available in AngelScript.
    void setAnimatedMeshSceneNodeEmitter(IAnimatedMeshSceneNode *node,
                                         bool useNormalDirection = true,
                                         const vector3df &direction = vector3df(0.0f, 0.03f, 0.0f),
                                         f32 normalDirectionModifier = 100.0f,
                                         bool everyMeshVertex = false,
                                         u32 minParticlesPerSecond = 5,
                                         u32 maxParticlesPerSecond = 10,
                                         const SColor &minStartColor = SColor(255, 0, 0, 0),
                                         const SColor &maxStartColor = SColor(255, 255, 255, 255),
                                         u32 lifeTimeMin = 2000, u32 lifeTimeMax = 4000,
                                         s32 maxAngleDegrees = 0,
                                         const dimension2df &minStartSize = dimension2df(5.0f, 5.0f),
                                         const dimension2df &maxStartSize = dimension2df(5.0f, 5.0f));

    //! Sets a box particle emitter.
    //!
    //! <b>XML:</b>
    //! \code
    //! <BoxEmitter>
    //!    <box minX="" minY="" minZ="" maxX="" maxY="" maxZ="" />
    //!    <direction x="" y="" z="" />
    //!    <minParticlesPerSecond value="" />
    //!    <maxParticlesPerSecond value="" />
    //!    <minStartColor a="" r="" g="" b="" />
    //!    <maxStartColor a="" r="" g="" b="" />
    //!    <lifeTimeMin value="" />
    //!    <lifeTimeMax value="" />
    //!    <maxAngleDegrees value="" />
    //!    <minStartSize width="" height="" />
    //!    <maxStartSize width="" height="" />
    //! </BoxEmitter>
    //! \endcode
    //!
    //! @param box                     The box for the emitter.
    //! @param direction               Direction and speed of particle emission.
    //! @param minParticlesPerSecond   Minimal amount of particles emitted per second.
    //! @param maxParticlesPerSecond   Maximal amount of particles emitted per second.
    //! @param minStartColor           Minimal initial start color of a particle.
    //! @param maxStartColor           Maximal initial start color of a particle.
    //! @param lifeTimeMin             Minimal lifetime of a particle, in milliseconds.
    //! @param lifeTimeMax             Maximal lifetime of a particle, in milliseconds.
    //! @param maxAngleDegrees         Maximal angle in degrees, the emitting direction of the
    //!                                particle will differ from the original direction.
    //! @param minStartSize            Minimal initial start size of a particle.
    //! @param maxStartSize            Maximal initial start size of a particle.
    void setBoxEmitter(const aabbox3df &box = aabbox3df(-10, 28,-10, 10, 30, 10),
                       const vector3df &direction = vector3df(0.0f, 0.03f, 0.0f),
                       u32 minParticlesPerSecond = 5, u32 maxParticlesPerSecond = 10,
                       const SColor &minStartColor = SColor(255, 0, 0, 0),
                       const SColor &maxStartColor = SColor(255, 255, 255, 255),
                       u32 lifeTimeMin = 2000, u32 lifeTimeMax = 4000, s32 maxAngleDegrees = 0,
                       const dimension2df &minStartSize = dimension2df(5.0f, 5.0f),
                       const dimension2df &maxStartSize = dimension2df(5.0f, 5.0f));

    //! Sets a particle emitter for emitting from a cylinder.
    //!
    //! <b>XML:</b>
    //! \code
    //! <CylinderEmitter>
    //!    <center x="" y="" z="" />
    //!    <radius value="" />
    //!    <normal x="" y="" z="" />
    //!    <length value="" />
    //!    <outlineOnly value="" />
    //!    <direction x="" y="" z="" />
    //!    <minParticlesPerSecond value="" />
    //!    <maxParticlesPerSecond value="" />
    //!    <minStartColor a="" r="" g="" b="" />
    //!    <maxStartColor a="" r="" g="" b="" />
    //!    <lifeTimeMin value="" />
    //!    <lifeTimeMax value="" />
    //!    <maxAngleDegrees value="" />
    //!    <minStartSize width="" height="" />
    //!    <maxStartSize width="" height="" />
    //! </CylinderEmitter>
    //! \endcode
    //!
    //! @param center                  The center of the circle at the base of the cylinder.
    //! @param radius                  The thickness of the cylinder
    //! @param normal                  Direction of the length of the cylinder
    //! @param length                  The length of the the cylinder
    //! @param outlineOnly             Whether or not to put points inside the cylinder or on the
    //!                                outline only
    //! @param direction               Direction and speed of particle emission.
    //! @param minParticlesPerSecond   Minimal amount of particles emitted per second.
    //! @param maxParticlesPerSecond   Maximal amount of particles emitted per second.
    //! @param minStartColor           Minimal initial start color of a particle.
    //! @param maxStartColor           Maximal initial start color of a particle.
    //! @param lifeTimeMin             Minimal lifetime of a particle, in milliseconds.
    //! @param lifeTimeMax             Maximal lifetime of a particle, in milliseconds.
    //! @param maxAngleDegrees         Maximal angle in degrees, the emitting direction of the
    //!                                particle will differ from the original direction.
    //! @param minStartSize            Minimal initial start size of a particle.
    //! @param maxStartSize            Maximal initial start size of a particle.
    void setCylinderEmitter(const vector3df &center, f32 radius, const vector3df &normal,
                            f32 length, bool outlineOnly = false,
                            const vector3df &direction = vector3df(0.0f, 0.03f, 0.0f),
                            u32 minParticlesPerSecond = 5, u32 maxParticlesPerSecond = 10,
                            const SColor &minStartColor = SColor(255, 0, 0, 0),
                            const SColor &maxStartColor = SColor(255, 255, 255, 255),
                            u32 lifeTimeMin = 2000, u32 lifeTimeMax = 4000, s32 maxAngleDegrees = 0,
                            const dimension2df &minStartSize = dimension2df(5.0f, 5.0f),
                            const dimension2df &maxStartSize = dimension2df(5.0f, 5.0f));

    //! Sets the particle emitter, which creates the particles.
    //! @note Not available in AngelScript.
    void setEmitter(IParticleEmitter *emitter);

    //! Sets a particle emitter for the loaded mesh.
    //!
    //! <b>XML:</b>
    //! \code
    //! <MeshEmitter>
    //!    <fileName value="" />
    //!    <useNormalDirection value="" />
    //!    <direction x="" y="" z="" />
    //!    <normalDirectionModifier value="" />
    //!    <everyMeshVertex value="" />
    //!    <minParticlesPerSecond value="" />
    //!    <maxParticlesPerSecond value="" />
    //!    <minStartColor a="" r="" g="" b="" />
    //!    <maxStartColor a="" r="" g="" b="" />
    //!    <lifeTimeMin value="" />
    //!    <lifeTimeMax value="" />
    //!    <maxAngleDegrees value="" />
    //!    <minStartSize width="" height="" />
    //!    <maxStartSize width="" height="" />
    //! </MeshEmitter>
    //! \endcode
    //!
    //! @param fileName                Filename of the mesh to load.
    //! @param useNormalDirection      If true, the direction of each particle created will be the
    //!                                normal of the vertex that it's emitting from. The normal is
    //!                                divided by the normalDirectionModifier parameter,
    //!                                which defaults to 100.0f.
    //! @param direction               Direction and speed of particle emission.
    //! @param normalDirectionModifier If the emitter is using the normal direction then the normal
    //!                                of the vertex that is being emitted from is divided by this
    //!                                number.
    //! @param everyMeshVertex         If true, the emitter will emit between min/max particles
    //!                                every second, for every vertex in the mesh, if false, it
    //!                                will emit between min/max particles from random vertices
    //!                                in the mesh.
    //! @param minParticlesPerSecond   Minimal amount of particles emitted per second.
    //! @param maxParticlesPerSecond   Maximal amount of particles emitted per second.
    //! @param minStartColor           Minimal initial start color of a particle.
    //! @param maxStartColor           Maximal initial start color of a particle.
    //! @param lifeTimeMin             Minimal lifetime of a particle, in milliseconds.
    //! @param lifeTimeMax             Maximal lifetime of a particle, in milliseconds.
    //! @param maxAngleDegrees         Maximal angle in degrees, the emitting direction of the
    //!                                particle will differ from the original direction.
    //! @param minStartSize            Minimal initial start size of a particle.
    //! @param maxStartSize            Maximal initial start size of a particle.
    void setMeshEmitter(const std::string &fileName, bool useNormalDirection = true,
                        const vector3df &direction = vector3df(0.0f, 0.03f, 0.0f),
                        f32 normalDirectionModifier = 100.0f, bool everyMeshVertex = false,
                        u32 minParticlesPerSecond = 5, u32 maxParticlesPerSecond = 10,
                        const SColor &minStartColor = SColor(255, 0, 0, 0),
                        const SColor &maxStartColor = SColor(255, 255, 255, 255),
                        u32 lifeTimeMin = 2000, u32 lifeTimeMax = 4000, s32 maxAngleDegrees = 0,
                        const dimension2df &minStartSize = dimension2df(5.0f, 5.0f),
                        const dimension2df &maxStartSize = dimension2df(5.0f, 5.0f));
    //! Sets a particle emitter for the loaded mesh.
    //! @param mesh                    Pointer to the loaded mesh.
    //! @param useNormalDirection      If true, the direction of each particle created will be the
    //!                                normal of the vertex that it's emitting from. The normal is
    //!                                divided by the normalDirectionModifier parameter,
    //!                                which defaults to 100.0f.
    //! @param direction               Direction and speed of particle emission.
    //! @param normalDirectionModifier If the emitter is using the normal direction then the normal
    //!                                of the vertex that is being emitted from is divided by this
    //!                                number.
    //! @param everyMeshVertex         If true, the emitter will emit between min/max particles
    //!                                every second, for every vertex in the mesh, if false, it
    //!                                will emit between min/max particles from random vertices
    //!                                in the mesh.
    //! @param minParticlesPerSecond   Minimal amount of particles emitted per second.
    //! @param maxParticlesPerSecond   Maximal amount of particles emitted per second.
    //! @param minStartColor           Minimal initial start color of a particle.
    //! @param maxStartColor           Maximal initial start color of a particle.
    //! @param lifeTimeMin             Minimal lifetime of a particle, in milliseconds.
    //! @param lifeTimeMax             Maximal lifetime of a particle, in milliseconds.
    //! @param maxAngleDegrees         Maximal angle in degrees, the emitting direction of the
    //!                                particle will differ from the original direction.
    //! @param minStartSize            Minimal initial start size of a particle.
    //! @param maxStartSize            Maximal initial start size of a particle.
    //! @note Not available in AngelScript.
    void setMeshEmitter(IMesh *mesh, bool useNormalDirection = true,
                        const vector3df &direction = vector3df(0.0f, 0.03f, 0.0f),
                        f32 normalDirectionModifier = 100.0f, bool everyMeshVertex = false,
                        u32 minParticlesPerSecond = 5, u32 maxParticlesPerSecond = 10,
                        const SColor &minStartColor = SColor(255, 0, 0, 0),
                        const SColor &maxStartColor = SColor(255, 255, 255, 255),
                        u32 lifeTimeMin = 2000, u32 lifeTimeMax = 4000, s32 maxAngleDegrees = 0,
                        const dimension2df &minStartSize = dimension2df(5.0f, 5.0f),
                        const dimension2df &maxStartSize = dimension2df(5.0f, 5.0f));

    //! Sets a point particle emitter.
    //!
    //! <b>XML:</b>
    //! \code
    //! <PointEmitter>
    //!    <direction x="" y="" z="" />
    //!    <minParticlesPerSecond value="" />
    //!    <maxParticlesPerSecond value="" />
    //!    <minStartColor a="" r="" g="" b="" />
    //!    <maxStartColor a="" r="" g="" b="" />
    //!    <lifeTimeMin value="" />
    //!    <lifeTimeMax value="" />
    //!    <maxAngleDegrees value="" />
    //!    <minStartSize width="" height="" />
    //!    <maxStartSize width="" height="" />
    //! </PointEmitter>
    //! \endcode
    //!
    //! @param direction               Direction and speed of particle emission.
    //! @param minParticlesPerSecond   Minimal amount of particles emitted per second.
    //! @param maxParticlesPerSecond   Maximal amount of particles emitted per second.
    //! @param minStartColor           Minimal initial start color of a particle.
    //! @param maxStartColor           Maximal initial start color of a particle.
    //! @param lifeTimeMin             Minimal lifetime of a particle, in milliseconds.
    //! @param lifeTimeMax             Maximal lifetime of a particle, in milliseconds.
    //! @param maxAngleDegrees         Maximal angle in degrees, the emitting direction of the
    //!                                particle will differ from the original direction.
    //! @param minStartSize            Minimal initial start size of a particle.
    //! @param maxStartSize            Maximal initial start size of a particle.
    void setPointEmitter(const vector3df &direction = vector3df(0.0f, 0.03f, 0.0f),
                         u32 minParticlesPerSecond = 5, u32 maxParticlesPerSecond = 10,
                         const SColor &minStartColor = SColor(255, 0, 0, 0),
                         const SColor &maxStartColor = SColor(255, 255, 255, 255),
                         u32 lifeTimeMin = 2000, u32 lifeTimeMax = 4000, s32 maxAngleDegrees = 0,
                         const dimension2df &minStartSize = dimension2df(5.0f, 5.0f),
                         const dimension2df &maxStartSize = dimension2df(5.0f, 5.0f));

    //! Sets a ring particle emitter.
    //!
    //! <b>XML:</b>
    //! \code
    //! <RingEmitter>
    //!    <center x="" y="" z="" />
    //!    <radius value="" />
    //!    <ringThickness value="" />
    //!    <direction x="" y="" z="" />
    //!    <minParticlesPerSecond value="" />
    //!    <maxParticlesPerSecond value="" />
    //!    <minStartColor a="" r="" g="" b="" />
    //!    <maxStartColor a="" r="" g="" b="" />
    //!    <lifeTimeMin value="" />
    //!    <lifeTimeMax value="" />
    //!    <maxAngleDegrees value="" />
    //!    <minStartSize width="" height="" />
    //!    <maxStartSize width="" height="" />
    //! </RingEmitter>
    //! \endcode
    //!
    //! @param center                  Center of ring.
    //! @param radius                  Distance of points from center, points will be rotated
    //!                                around the Y axis at a random 360 degrees and will then
    //!                                be shifted by the provided ringThickness values in each axis.
    //! @param ringThickness           Thickness of the ring.
    //! @param direction               Direction and speed of particle emission.
    //! @param minParticlesPerSecond   Minimal amount of particles emitted per second.
    //! @param maxParticlesPerSecond   Maximal amount of particles emitted per second.
    //! @param minStartColor           Minimal initial start color of a particle.
    //! @param maxStartColor           Maximal initial start color of a particle.
    //! @param lifeTimeMin             Minimal lifetime of a particle, in milliseconds.
    //! @param lifeTimeMax             Maximal lifetime of a particle, in milliseconds.
    //! @param maxAngleDegrees         Maximal angle in degrees, the emitting direction of the
    //!                                particle will differ from the original direction.
    //! @param minStartSize            Minimal initial start size of a particle.
    //! @param maxStartSize            Maximal initial start size of a particle.
    void setRingEmitter(const vector3df &center, f32 radius, f32 ringThickness,
                        const vector3df &direction = vector3df(0.0f, 0.03f, 0.0f),
                        u32 minParticlesPerSecond = 5, u32 maxParticlesPerSecond = 10,
                        const SColor &minStartColor = SColor(255, 0, 0, 0),
                        const SColor &maxStartColor = SColor(255, 255, 255, 255),
                        u32 lifeTimeMin = 2000, u32 lifeTimeMax = 4000, s32 maxAngleDegrees = 0,
                        const dimension2df &minStartSize = dimension2df(5.0f, 5.0f),
                        const dimension2df &maxStartSize = dimension2df(5.0f, 5.0f));

    //! Sets a sphere particle emitter.
    //!
    //! <b>XML:</b>
    //! \code
    //! <SphereEmitter>
    //!    <center x="" y="" z="" />
    //!    <radius value="" />
    //!    <direction x="" y="" z="" />
    //!    <minParticlesPerSecond value="" />
    //!    <maxParticlesPerSecond value="" />
    //!    <minStartColor a="" r="" g="" b="" />
    //!    <maxStartColor a="" r="" g="" b="" />
    //!    <lifeTimeMin value="" />
    //!    <lifeTimeMax value="" />
    //!    <maxAngleDegrees value="" />
    //!    <minStartSize width="" height="" />
    //!    <maxStartSize width="" height="" />
    //! </SphereEmitter>
    //! \endcode
    //!
    //! @param center                  Center of the sphere.
    //! @param radius                  Radius of the sphere.
    //! @param direction               Direction and speed of particle emission.
    //! @param minParticlesPerSecond   Minimal amount of particles emitted per second.
    //! @param maxParticlesPerSecond   Maximal amount of particles emitted per second.
    //! @param minStartColor           Minimal initial start color of a particle.
    //! @param maxStartColor           Maximal initial start color of a particle.
    //! @param lifeTimeMin             Minimal lifetime of a particle, in milliseconds.
    //! @param lifeTimeMax             Maximal lifetime of a particle, in milliseconds.
    //! @param maxAngleDegrees         Maximal angle in degrees, the emitting direction of the
    //!                                particle will differ from the original direction.
    //! @param minStartSize            Minimal initial start size of a particle.
    //! @param maxStartSize            Maximal initial start size of a particle.
    void setSphereEmitter(const vector3df &center, f32 radius,
                          const vector3df &direction = vector3df(0.0f, 0.03f, 0.0f),
                          u32 minParticlesPerSecond = 5, u32 maxParticlesPerSecond = 10,
                          const SColor &minStartColor = SColor(255, 0, 0, 0),
                          const SColor &maxStartColor = SColor(255, 255, 255, 255),
                          u32 lifeTimeMin = 2000, u32 lifeTimeMax = 4000, s32 maxAngleDegrees = 0,
                          const dimension2df &minStartSize = dimension2df(5.0f, 5.0f),
                          const dimension2df &maxStartSize = dimension2df(5.0f, 5.0f));

    //! Sets if the particles should be global.
    //! @param value         Value to enable or disable this option.
    void setParticlesAreGlobal(bool value = true);
    //! Sets the size of all particles.
    //! @param size          Global particle size.
    void setParticleSize(const dimension2df &size = dimension2df(5.0f, 5.0f));

    // XML
    //! Parses for a ParticleSysComponent.
    //! @note For internal use only!
    static bool parseXML(IXMLReader *file, Entity *entity);

private:

    // Members
    IParticleSystemSceneNode *mParticleSystemSN;
};

#endif
